var runtime.gcController
148 uses
runtime (current package)
arena.go#L883: gcController.heapInUse.add(-int64(s.npages * pageSize))
arena.go#L889: gcController.totalFree.Add(int64(s.elemsize))
arena.go#L903: gcController.update(-int64(s.elemsize), 0)
arena.go#L1044: sysMap(unsafe.Pointer(base), userArenaChunkBytes, &gcController.heapReleased)
arena.go#L1070: gcController.heapInUse.add(int64(userArenaChunkBytes))
arena.go#L1071: gcController.heapReleased.add(-int64(userArenaChunkBytes))
arena.go#L1083: gcController.totalAlloc.Add(int64(s.elemsize))
arena.go#L1086: gcController.update(int64(s.elemsize), 0)
malloc.go#L631: gcController.memoryLimit.Store(maxInt64)
malloc.go#L661: v = h.arena.alloc(n, heapArenaBytes, &gcController.heapReleased)
mcache.go#L176: gcController.totalAlloc.Add(bytesAllocated)
mcache.go#L213: gcController.update(int64(s.npages*pageSize)-int64(usedBytes), int64(c.scanAlloc))
mcache.go#L247: gcController.totalAlloc.Add(int64(npages * pageSize))
mcache.go#L250: gcController.update(int64(s.npages*pageSize), 0)
mcache.go#L288: gcController.totalAlloc.Add(slotsUsed * int64(s.elemsize))
mcache.go#L315: gcController.update(dHeapLive, scanAlloc)
mem.go#L51: gcController.mappedReady.Add(int64(n))
mem.go#L61: gcController.mappedReady.Add(-int64(n))
mem.go#L76: gcController.mappedReady.Add(int64(prepared))
mem.go#L115: gcController.mappedReady.Add(-int64(n))
mem.go#L129: gcController.mappedReady.Add(-int64(n))
metrics.go#L282: out.scalar = uint64(gcController.memoryLimit.Load())
metrics.go#L288: out.scalar = uint64(gcController.gcPercent.Load())
metrics.go#L295: out.scalar = gcController.heapMarked
metrics.go#L652: a.heapGoal = gcController.heapGoal()
metrics.go#L693: a.heapScan = gcController.heapScan.Load()
metrics.go#L694: a.stackScan = gcController.lastStackScan.Load()
metrics.go#L695: a.globalsScan = gcController.globalsScan.Load()
mgc.go#L187: gcController.init(readGOGC(), readGOMEMLIMIT())
mgc.go#L304: delta := now - gcController.markStartTime
mgc.go#L312: return float64(selfTime)/float64(delta) > 1.2*gcController.fractionalUtilizationGoal
mgc.go#L608: trigger, _ := gcController.trigger()
mgc.go#L609: return gcController.heapLive.Load() >= trigger
mgc.go#L611: if gcController.gcPercent.Load() < 0 {
mgc.go#L718: work.heap0 = gcController.heapLive.Load()
mgc.go#L745: gcController.startCycle(now, int(gomaxprocs), trigger)
mgc.go#L1011: gcController.endCycle(now, int(gomaxprocs), work.userForced)
mgc.go#L1023: work.heap1 = gcController.heapLive.Load()
mgc.go#L1090: memstats.lastHeapInUse = gcController.heapInUse.load()
mgc.go#L1256: gcController.assistTime.Load(),
mgc.go#L1257: gcController.dedicatedMarkTime.Load() + gcController.fractionalMarkTime.Load(),
mgc.go#L1258: gcController.idleMarkTime.Load(),
mgc.go#L1271: gcController.lastHeapGoal>>20, " MB goal, ",
mgc.go#L1272: gcController.lastStackScan.Load()>>20, " MB stacks, ",
mgc.go#L1273: gcController.globalsScan.Load()>>20, " MB globals, ",
mgc.go#L1292: if gcController.heapGoal() > minHeapForMetadataHugePages {
mgc.go#L1528: gcController.markWorkerStop(pp.gcMarkWorkerMode, duration)
mgc.go#L1666: gcController.resetLive(work.bytesMarked)
mgc.go#L1759: work.initialHeapLive = gcController.heapLive.Load()
mgcmark.go#L167: workCounter = &gcController.globalsScanWork
mgcmark.go#L173: workCounter = &gcController.globalsScanWork
mgcmark.go#L197: workCounter = &gcController.stackScanWork
mgcmark.go#L485: assistWorkPerByte := gcController.assistWorkPerByte.Load()
mgcmark.go#L486: assistBytesPerWork := gcController.assistBytesPerWork.Load()
mgcmark.go#L500: bgScanCredit := gcController.bgScanCredit.Load()
mgcmark.go#L510: gcController.bgScanCredit.Add(-stolen)
mgcmark.go#L680: assistBytesPerWork := gcController.assistBytesPerWork.Load()
mgcmark.go#L707: gcController.assistTime.Add(pp.gcAssistTime)
mgcmark.go#L745: if gcController.bgScanCredit.Load() > 0 {
mgcmark.go#L774: gcController.bgScanCredit.Add(scanWork)
mgcmark.go#L778: assistBytesPerWork := gcController.assistBytesPerWork.Load()
mgcmark.go#L812: assistWorkPerByte := gcController.assistWorkPerByte.Load()
mgcmark.go#L814: gcController.bgScanCredit.Add(scanWork)
mgcmark.go#L1234: gcController.heapScanWork.Add(gcw.heapScanWork)
mgcmark.go#L1254: gcController.heapScanWork.Add(gcw.heapScanWork)
mgcmark.go#L1321: gcController.heapScanWork.Add(gcw.heapScanWork)
mgcpacer.go#L88: var gcController gcControllerState
mgcpacer.go#L460: " (scan ", gcController.heapScan.Load()>>20, " MB in ",
mgcpacer.go#L601: gcController.lastHeapGoal = c.heapGoal()
mgcpacer.go#L875: live := gcController.heapLive.Add(dHeapLive)
mgcpacer.go#L886: gcController.heapScan.Add(dHeapScan)
mgcpacer.go#L1274: out = gcController.setGCPercent(in)
mgcpacer.go#L1321: out = gcController.setMemoryLimit(in)
mgcpacer.go#L1439: gcController.commit(isSweepDone())
mgcpacer.go#L1443: gcController.revise()
mgcpacer.go#L1454: trigger, heapGoal := gcController.trigger()
mgcpacer.go#L1456: gcPaceScavenger(gcController.memoryLimit.Load(), heapGoal, gcController.lastHeapGoal)
mgcscavenge.go#L151: return gcController.heapInUse.load() + gcController.heapFree.load()
mgcscavenge.go#L179: mappedReady := gcController.mappedReady.Load()
mgcscavenge.go#L408: gcController.mappedReady.Load() <= scavenge.memoryLimitGoal.Load()
mgcscavenge.go#L706: gcController.heapReleased.load()>>10, " KiB now, ",
mgcscavenge.go#L707: (gcController.heapInUse.load()*100)/heapRetained(), "% util",
mgcscavenge.go#L783: gcController.heapReleased.add(nbytes)
mgcscavenge.go#L784: gcController.heapFree.add(-nbytes)
mgcsweep.go#L176: live := gcController.heapLive.Load()
mgcsweep.go#L762: gcController.totalFree.Add(int64(nfreed) * int64(s.elemsize))
mgcsweep.go#L798: gcController.totalFree.Add(int64(size))
mgcsweep.go#L912: live := gcController.heapLive.Load()
mgcsweep.go#L978: heapLiveBasis := gcController.heapLive.Load()
mgcwork.go#L144: gcController.enlistWorker()
mgcwork.go#L193: gcController.enlistWorker()
mgcwork.go#L279: gcController.heapScanWork.Add(w.heapScanWork)
mgcwork.go#L304: gcController.enlistWorker()
mheap.go#L1283: if limit := gcController.memoryLimit.Load(); !gcCPULimiter.limiting() {
mheap.go#L1286: inuse := gcController.mappedReady.Load()
mheap.go#L1354: gcController.heapReleased.add(-int64(scav))
mheap.go#L1357: gcController.heapFree.add(-int64(nbytes - scav))
mheap.go#L1359: gcController.heapInUse.add(int64(nbytes))
mheap.go#L1501: inUse := gcController.heapFree.load() + gcController.heapReleased.load() + gcController.heapInUse.load()
mheap.go#L1518: sysMap(unsafe.Pointer(h.curArena.base), size, &gcController.heapReleased)
mheap.go#L1549: sysMap(unsafe.Pointer(v), nBase-v, &gcController.heapReleased)
mheap.go#L1650: gcController.heapFree.add(int64(nbytes))
mheap.go#L1652: gcController.heapInUse.add(-int64(nbytes))
mstats.go#L436: totalMapped := gcController.heapInUse.load() + gcController.heapFree.load() + gcController.heapReleased.load() +
mstats.go#L441: heapGoal := gcController.heapGoal()
mstats.go#L463: if gcController.heapInUse.load() != uint64(consStats.inHeap) {
mstats.go#L464: print("runtime: heapInUse=", gcController.heapInUse.load(), "\n")
mstats.go#L468: if gcController.heapReleased.load() != uint64(consStats.released) {
mstats.go#L469: print("runtime: heapReleased=", gcController.heapReleased.load(), "\n")
mstats.go#L473: heapRetained := gcController.heapInUse.load() + gcController.heapFree.load()
mstats.go#L480: if gcController.totalAlloc.Load() != totalAlloc {
mstats.go#L481: print("runtime: totalAlloc=", gcController.totalAlloc.Load(), "\n")
mstats.go#L485: if gcController.totalFree.Load() != totalFree {
mstats.go#L486: print("runtime: totalFree=", gcController.totalFree.Load(), "\n")
mstats.go#L493: if gcController.mappedReady.Load() != totalMapped-uint64(consStats.released) {
mstats.go#L494: print("runtime: mappedReady=", gcController.mappedReady.Load(), "\n")
mstats.go#L512: stats.HeapSys = gcController.heapInUse.load() + gcController.heapFree.load() + gcController.heapReleased.load()
mstats.go#L529: stats.HeapIdle = gcController.heapFree.load() + gcController.heapReleased.load()
mstats.go#L530: stats.HeapInuse = gcController.heapInUse.load()
mstats.go#L531: stats.HeapReleased = gcController.heapReleased.load()
mstats.go#L951: markAssistCpu = gcController.assistTime.Load()
mstats.go#L952: markDedicatedCpu = gcController.dedicatedMarkTime.Load()
mstats.go#L953: markFractionalCpu = gcController.fractionalMarkTime.Load()
mstats.go#L954: markIdleCpu = gcController.idleMarkTime.Load()
proc.go#L3331: gp, tnow := gcController.findRunnableGCWorker(pp, now)
proc.go#L3429: if gcBlackenEnabled != 0 && gcMarkWorkAvailable(pp) && gcController.addIdleMarkWorker() {
proc.go#L3443: gcController.removeIdleMarkWorker()
proc.go#L3817: if atomic.Load(&gcBlackenEnabled) == 0 || !gcController.needIdleMarkWorker() {
proc.go#L3849: if gcBlackenEnabled == 0 || !gcController.addIdleMarkWorker() {
proc.go#L3859: gcController.removeIdleMarkWorker()
proc.go#L4339: gcController.addScannableStack(pp, -int64(gp.stack.hi-gp.stack.lo))
proc.go#L4362: assistWorkPerByte := gcController.assistWorkPerByte.Load()
proc.go#L4364: gcController.bgScanCredit.Add(scanCredit)
proc.go#L5122: gcController.addScannableStack(pp, int64(newg.stack.hi-newg.stack.lo))
stack.go#L871: gcController.addScannableStack(getg().m.p.ptr(), int64(newsize)-int64(old.hi-old.lo))
symtab.go#L547: gcController.addGlobals(int64(scanDataSize + scanBSSSize))
traceruntime.go#L575: heapGoal := gcController.heapGoal()